/**
 * 
 */
package org.quickbundle.project.filter;

import java.io.UnsupportedEncodingException;
import java.util.Map;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import com.dfhc.ISystemConstant;

/**
 * @author tongweiqi
 *
 */
public class DispatcherWrapper extends HttpServletRequestWrapper {
	
	// 定义一个标记，用来标注：当前requset中，请求参数，是否已经编码过了
	private boolean flag = false;
	
	 public DispatcherWrapper(HttpServletRequest request) {
         super(request);
     }
     @Override
     public Object getAttribute(String name) {
         // TOMCAT内部的请求分发属性
         if ("org.apache.catalina.core.DISPATCHER_TYPE".equals(name)) {
             Object forward = this.getAttribute(ISystemConstant.FILTER_FORWARD);
             if (forward == Boolean.TRUE) {
                 //这里返回变量有两种,在Tomcat6中并没有DispacherType这个类,与REQUEST相对应的是一个int类型的数值8
                 //这个属性在Tomcat7后才被抽象为一个类
                 //所以这里要判断下如果有这个类则返回DisPacherType.REQUEST否则返回8即可
                 try {
                     Class.forName("javax.servlet.DispatcherType");
                     return javax.servlet.DispatcherType.REQUEST;
                 } catch (Exception e) {
                     return 8;
                 }
             }
         }
         return super.getAttribute(name);
     }
     
     
     
     @Override
     public Map<String, String[]> getParameterMap() {
    	 
    	 HttpServletRequest request = (HttpServletRequest) super.getRequest();
    	
         // 获得请求方式request.getMethod()方法
         String method = ((HttpServletRequest)super.getRequest()).getMethod();
         // post请求
         if ("post".equalsIgnoreCase(method)) {
        	 Map<String, String[]> map = request.getParameterMap();
             return map;
  
         } else if ("get".equalsIgnoreCase(method)) {
             // get请求
             // 分析：get请求需要对每一个参数都进行转换，因此需要对map中的每个元素进行遍历
             // 首先获得map集合
             Map<String, String[]> map = request.getParameterMap();
  
             //第一次获取请求参数，flag==false，执行后面的额乱码处理动作
             //第二次获取请求参数的时候，flag==true，不执行后面的处理，直接返回已经编码过的map集合
             if (flag) {
                 return map;
             }
             if (map == null) {
                 return super.getParameterMap();
             } else {
                 // 然后获得map集合的key
                 Set<String> key = map.keySet();
                 // 通过key将map中的元素取出来
                 for (String string : key) {
                     String[] value = map.get(string);
                     // 接下来需要将String中的每一个都进行遍历，转换参数
                     for (int i = 0; i < value.length; i++) {
                         try {
                             String string2 = new String(value[i].getBytes(ISystemConstant.ENCODE_ISO_8859_1), ISystemConstant.ENCODE_UTF_8);
                             value[i] = string2;
                         } catch (UnsupportedEncodingException e) {
                             e.printStackTrace();
                         }
                     }
                 }
                 flag = true;
                 return map;
             }
         } else {
             //位置请求方式，自定义对象处理不了，使用父类的方法处理
             return super.getParameterMap();
         }
     }
     
     
     @Override
	 public String[] getParameterValues(String name) {
	   // 通过map集合获取参数
	   Map<String, String[]> map = this.getParameterMap();
	   if (map == null) {
	       return super.getParameterValues(name);
	   } else {
	       String[] strings = map.get(name);
	       return strings;
	   }
	}
	
	@Override
	public String getParameter(String name) {
	  // 通过values获取参数
	  String[] values = this.getParameterValues(name);
	  if (values == null) {
	      return super.getParameter(name);
	  } else {
	      return values[0];
	  }
	}
     
     
}
